ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು: ಆಧುನಿಕ ಅಭಿವೃದ್ಧಿಗಾಗಿ ಸ್ಟ್ರೀಮ್ ಯುಟಿಲಿಟೀಸ್

ES2023 ರಲ್ಲಿ ಪರಿಚಯಿಸಲಾದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳು, ಅಸಿಂಕ್ರೊನಸ್ ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಶಕ್ತಿಯುತ ಮತ್ತು ಅರ್ಥಗರ್ಭಿತ ಸಾಧನಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ. ಈ ಯುಟಿಲಿಟೀಸ್‌ಗಳು ಸಾಮಾನ್ಯ ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಕಾರ್ಯಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತವೆ, ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಓದಬಲ್ಲ, ನಿರ್ವಹಿಸಬಲ್ಲ, ಮತ್ತು ದಕ್ಷವಾಗಿಸುತ್ತವೆ. ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ ಈ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತದೆ, ಎಲ್ಲಾ ಹಂತಗಳ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಒಳನೋಟಗಳನ್ನು ನೀಡುತ್ತದೆ.

ಅಸಿಂಕ್ ಜೆನರೇಟರ್ಸ್ ಮತ್ತು ಅಸಿಂಕ್ ಇಟರೇಟರ್ಸ್ ಎಂದರೇನು?

ಹೆಲ್ಪರ್‌ಗಳ ಬಗ್ಗೆ ತಿಳಿಯುವ ಮೊದಲು, ಅಸಿಂಕ್ ಜೆನರೇಟರ್ಸ್ ಮತ್ತು ಅಸಿಂಕ್ ಇಟರೇಟರ್ಸ್ ಬಗ್ಗೆ ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಪುನರಾವಲೋಕಿಸೋಣ. ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಎನ್ನುವುದು ಒಂದು ಫಂಕ್ಷನ್ ಆಗಿದ್ದು ಅದು ತನ್ನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ವಿರಾಮಗೊಳಿಸಿ ಅಸಿಂಕ್ರೊನಸ್ ಮೌಲ್ಯಗಳನ್ನು ನೀಡಬಲ್ಲದು. ಇದು ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅದು ಆ ಮೌಲ್ಯಗಳ ಮೇಲೆ ಅಸಿಂಕ್ರೊನಸ್ ಆಗಿ ಪುನರಾವರ್ತಿಸಲು ಒಂದು ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಇಲ್ಲಿ ಒಂದು ಮೂಲಭೂತ ಉದಾಹರಣೆ ಇದೆ:

            
async function* generateNumbers(max) {
  for (let i = 0; i < max; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // Simulate async operation
    yield i;
  }
}

async function main() {
  const numberStream = generateNumbers(5);

  for await (const number of numberStream) {
    console.log(number); // Output: 0, 1, 2, 3, 4 (with delays)
  }
}

main();

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, `generateNumbers` ಒಂದು ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಫಂಕ್ಷನ್ ಆಗಿದೆ. ಇದು 0 ರಿಂದ `max` (ಹೊರತುಪಡಿಸಿ) ವರೆಗಿನ ಸಂಖ್ಯೆಗಳನ್ನು ನೀಡುತ್ತದೆ, ಪ್ರತಿ ಯೀಲ್ಡ್ ನಡುವೆ 500ms ವಿಳಂಬದೊಂದಿಗೆ. `for await...of` ಲೂಪ್ `generateNumbers` ನಿಂದ ಹಿಂತಿರುಗಿದ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ.

ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳ ಪರಿಚಯ

ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳು ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ವಿಸ್ತರಿಸುತ್ತವೆ, ಅಸಿಂಕ್ರೊನಸ್ ಸ್ಟ್ರೀಮ್‌ಗಳಲ್ಲಿ ಡೇಟಾ ಹರಿವನ್ನು ಪರಿವರ್ತಿಸಲು, ಫಿಲ್ಟರ್ ಮಾಡಲು ಮತ್ತು ನಿಯಂತ್ರಿಸಲು ವಿಧಾನಗಳನ್ನು ನೀಡುತ್ತವೆ. ಈ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸಬಹುದಾದಂತೆ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ, ಸಂಕೀರ್ಣ ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಪೈಪ್‌ಲೈನ್‌ಗಳಿಗಾಗಿ ನೀವು ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಒಟ್ಟಿಗೆ ಜೋಡಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಪ್ರಮುಖ ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳು ಇವು:

• `AsyncIterator.prototype.filter(predicate)`: ಹೊಸ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಅದು `predicate` ಫಂಕ್ಷನ್ ಸತ್ಯವಾದ (truthy) ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುವ ಮೌಲ್ಯಗಳನ್ನು ಮಾತ್ರ ನೀಡುತ್ತದೆ.
• `AsyncIterator.prototype.map(transform)`: ಹೊಸ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಅದು ಪ್ರತಿ ಮೌಲ್ಯದ ಮೇಲೆ `transform` ಫಂಕ್ಷನ್ ಅನ್ನು ಕರೆದ ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡುತ್ತದೆ.
• `AsyncIterator.prototype.take(limit)`: ಹೊಸ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಅದು ಮೊದಲ `limit` ಮೌಲ್ಯಗಳನ್ನು ಮಾತ್ರ ನೀಡುತ್ತದೆ.
• `AsyncIterator.prototype.drop(amount)`: ಹೊಸ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಅದು ಮೊದಲ `amount` ಮೌಲ್ಯಗಳನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ.
• `AsyncIterator.prototype.forEach(callback)`: ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ನಿಂದ ಪ್ರತಿ ಮೌಲ್ಯಕ್ಕೆ ಒಮ್ಮೆ ಒದಗಿಸಿದ ಫಂಕ್ಷನ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ಇದು ಒಂದು ಟರ್ಮಿನಲ್ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದೆ (ಇಟರೇಟರ್ ಅನ್ನು ಬಳಸುತ್ತದೆ).
• `AsyncIterator.prototype.toArray()`: ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ನಿಂದ ಎಲ್ಲಾ ಮೌಲ್ಯಗಳನ್ನು ಒಂದು ಅರೇಗೆ ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಇದು ಒಂದು ಟರ್ಮಿನಲ್ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದೆ.
• `AsyncIterator.prototype.reduce(reducer, initialValue)`: ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ನ ಪ್ರತಿ ಮೌಲ್ಯ ಮತ್ತು ಅಕ್ಯುಮ್ಯುಲೇಟರ್ ವಿರುದ್ಧ ಫಂಕ್ಷನ್ ಅನ್ನು ಅನ್ವಯಿಸಿ ಅದನ್ನು ಒಂದೇ ಮೌಲ್ಯಕ್ಕೆ ಇಳಿಸುತ್ತದೆ. ಇದು ಒಂದು ಟರ್ಮಿನಲ್ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದೆ.
• `AsyncIterator.from(iterable)`: ಸಿಂಕ್ರೊನಸ್ ಇಟರೇಬಲ್ ಅಥವಾ ಇನ್ನೊಂದು ಅಸಿಂಕ್ ಇಟರೇಬಲ್‌ನಿಂದ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು

ಈ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಅನ್ವೇಷಿಸೋಣ.

`filter()` ನೊಂದಿಗೆ ಡೇಟಾವನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದು

ನೀವು ಒಂದು ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಭಾವಿಸೋಣ, ಅದು ಸೆನ್ಸರ್ ರೀಡಿಂಗ್‌ಗಳ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ನೀಡುತ್ತದೆ, ಮತ್ತು ನೀವು ನಿರ್ದಿಷ್ಟ ಮಿತಿಗಿಂತ ಕೆಳಗಿರುವ ರೀಡಿಂಗ್‌ಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ಬಯಸುತ್ತೀರಿ.

            
async function* getSensorReadings() {
  // Simulate fetching sensor data from a remote source
  yield 20;
  yield 15;
  yield 25;
  yield 10;
  yield 30;
}

async function main() {
  const readings = getSensorReadings();
  const filteredReadings = readings.filter(reading => reading >= 20);

  for await (const reading of filteredReadings) {
    console.log(reading); // Output: 20, 25, 30
  }
}

main();

            

              
                Copy
              
            
          

`filter()` ಹೆಲ್ಪರ್ ಹೊಸ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಅದು 20 ಕ್ಕಿಂತ ಹೆಚ್ಚಿರುವ ಅಥವಾ ಸಮನಾದ ರೀಡಿಂಗ್‌ಗಳನ್ನು ಮಾತ್ರ ನೀಡುತ್ತದೆ.

`map()` ನೊಂದಿಗೆ ಡೇಟಾವನ್ನು ಪರಿವರ್ತಿಸುವುದು

ನೀವು ಒಂದು ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಭಾವಿಸೋಣ, ಅದು ಸೆಲ್ಸಿಯಸ್‌ನಲ್ಲಿ ತಾಪಮಾನ ಮೌಲ್ಯಗಳನ್ನು ನೀಡುತ್ತದೆ, ಮತ್ತು ನೀವು ಅವುಗಳನ್ನು ಫ್ಯಾರನ್‌ಹೀಟ್‌ಗೆ ಪರಿವರ್ತಿಸಲು ಬಯಸುತ್ತೀರಿ.

            
async function* getCelsiusTemperatures() {
  yield 0;
  yield 10;
  yield 20;
  yield 30;
}

async function main() {
  const celsiusTemperatures = getCelsiusTemperatures();
  const fahrenheitTemperatures = celsiusTemperatures.map(celsius => (celsius * 9/5) + 32);

  for await (const fahrenheit of fahrenheitTemperatures) {
    console.log(fahrenheit); // Output: 32, 50, 68, 86
  }
}

main();

            

              
                Copy
              
            
          

`map()` ಹೆಲ್ಪರ್ ಪ್ರತಿ ತಾಪಮಾನ ಮೌಲ್ಯಕ್ಕೆ ಸೆಲ್ಸಿಯಸ್-ಟು-ಫ್ಯಾರನ್‌ಹೀಟ್ ಪರಿವರ್ತನಾ ಫಂಕ್ಷನ್ ಅನ್ನು ಅನ್ವಯಿಸುತ್ತದೆ.

`take()` ನೊಂದಿಗೆ ಡೇಟಾವನ್ನು ಸೀಮಿತಗೊಳಿಸುವುದು

ನಿಮಗೆ ಅಸಿಂಕ್ ಜೆನರೇಟರ್‌ನಿಂದ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಮೌಲ್ಯಗಳು ಮಾತ್ರ ಬೇಕಿದ್ದರೆ, ನೀವು `take()` ಹೆಲ್ಪರ್ ಅನ್ನು ಬಳಸಬಹುದು.

            
async function* getLogEntries() {
  // Simulate reading log entries from a file
  yield 'Log entry 1';
  yield 'Log entry 2';
  yield 'Log entry 3';
  yield 'Log entry 4';
  yield 'Log entry 5';
}

async function main() {
  const logEntries = getLogEntries();
  const firstThreeEntries = logEntries.take(3);

  for await (const entry of firstThreeEntries) {
    console.log(entry); // Output: Log entry 1, Log entry 2, Log entry 3
  }
}

main();

            

              
                Copy
              
            
          

`take(3)` ಹೆಲ್ಪರ್ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಮೊದಲ ಮೂರು ಲಾಗ್ ಎಂಟ್ರಿಗಳಿಗೆ ಸೀಮಿತಗೊಳಿಸುತ್ತದೆ.

`drop()` ನೊಂದಿಗೆ ಡೇಟಾವನ್ನು ಬಿಟ್ಟುಬಿಡುವುದು

`drop()` ಹೆಲ್ಪರ್ ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ನ ಆರಂಭದಿಂದ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಮೌಲ್ಯಗಳನ್ನು ಬಿಟ್ಟುಬಿಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

            
async function* getItems() {
  yield 'Item 1';
  yield 'Item 2';
  yield 'Item 3';
  yield 'Item 4';
  yield 'Item 5';
}

async function main() {
  const items = getItems();
  const remainingItems = items.drop(2);

  for await (const item of remainingItems) {
    console.log(item); // Output: Item 3, Item 4, Item 5
  }
}

main();

            

              
                Copy
              
            
          

`drop(2)` ಹೆಲ್ಪರ್ ಮೊದಲ ಎರಡು ಐಟಂಗಳನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ.

`forEach()` ನೊಂದಿಗೆ ಸೈಡ್ ಎಫೆಕ್ಟ್ಸ್ ನಿರ್ವಹಿಸುವುದು

`forEach()` ಹೆಲ್ಪರ್ ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ನಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ಎಲಿಮೆಂಟ್‌ಗೆ ಕಾಲ್‌ಬ್ಯಾಕ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದು ಟರ್ಮಿನಲ್ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದೆ ಎಂಬುದನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವುದು ಮುಖ್ಯ; `forEach` ಅನ್ನು ಕರೆದ ನಂತರ, ಇಟರೇಟರ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

            
async function* getDataPoints() {
  yield 1;
  yield 2;
  yield 3;
}

async function main() {
  const dataPoints = getDataPoints();

  await dataPoints.forEach(dataPoint => {
    console.log(`Processing data point: ${dataPoint}`);
  });

  // The iterator is now consumed.
}

main();

            

              
                Copy
              
            
          

`toArray()` ನೊಂದಿಗೆ ಮೌಲ್ಯಗಳನ್ನು ಅರೇಗೆ ಸಂಗ್ರಹಿಸುವುದು

`toArray()` ಹೆಲ್ಪರ್ ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ನಿಂದ ಎಲ್ಲಾ ಮೌಲ್ಯಗಳನ್ನು ಒಂದು ಅರೇಗೆ ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಇದು ಮತ್ತೊಂದು ಟರ್ಮಿನಲ್ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದೆ.

            
async function* getFruits() {
  yield 'apple';
  yield 'banana';
  yield 'orange';
}

async function main() {
  const fruits = getFruits();
  const fruitArray = await fruits.toArray();

  console.log(fruitArray); // Output: ['apple', 'banana', 'orange']
}

main();

            

              
                Copy
              
            
          

`reduce()` ನೊಂದಿಗೆ ಮೌಲ್ಯಗಳನ್ನು ಒಂದೇ ಫಲಿತಾಂಶಕ್ಕೆ ಇಳಿಸುವುದು

`reduce()` ಹೆಲ್ಪರ್ ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ನ ಪ್ರತಿ ಮೌಲ್ಯ ಮತ್ತು ಅಕ್ಯುಮ್ಯುಲೇಟರ್ ವಿರುದ್ಧ ಫಂಕ್ಷನ್ ಅನ್ನು ಅನ್ವಯಿಸಿ ಅದನ್ನು ಒಂದೇ ಮೌಲ್ಯಕ್ಕೆ ಇಳಿಸುತ್ತದೆ. ಇದು ಒಂದು ಟರ್ಮಿನಲ್ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದೆ.

            
async function* getNumbers() {
  yield 1;
  yield 2;
  yield 3;
  yield 4;
}

async function main() {
  const numbers = getNumbers();
  const sum = await numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0);

  console.log(sum); // Output: 10
}

main();

            

              
                Copy
              
            
          

`from()` ನೊಂದಿಗೆ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಇಟರೇಬಲ್‌ಗಳಿಂದ ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳನ್ನು ರಚಿಸುವುದು

`from()` ಹೆಲ್ಪರ್ ನಿಮಗೆ ಸಿಂಕ್ರೊನಸ್ ಇಟರೇಬಲ್ (ಅರೇಯಂತಹ) ಅಥವಾ ಇನ್ನೊಂದು ಅಸಿಂಕ್ ಇಟರೇಬಲ್‌ನಿಂದ ಸುಲಭವಾಗಿ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಅನ್ನು ರಚಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.

            
async function main() {
  const syncArray = [1, 2, 3];
  const asyncIteratorFromArray = AsyncIterator.from(syncArray);

  for await (const number of asyncIteratorFromArray) {
    console.log(number); // Output: 1, 2, 3
  }

  async function* asyncGenerator() {
    yield 4;
    yield 5;
    yield 6;
  }

  const asyncIteratorFromGenerator = AsyncIterator.from(asyncGenerator());

  for await (const number of asyncIteratorFromGenerator) {
    console.log(number); // Output: 4, 5, 6
  }
}

main();

            

              
                Copy
              
            
          

ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸುವುದು

ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳ ನಿಜವಾದ ಶಕ್ತಿ ಅವುಗಳ ಸಂಯೋಜನೆಯಲ್ಲಿದೆ. ಸಂಕೀರ್ಣ ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ರಚಿಸಲು ನೀವು ಅನೇಕ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಒಟ್ಟಿಗೆ ಜೋಡಿಸಬಹುದು.

ಉದಾಹರಣೆಗೆ, ನೀವು API ನಿಂದ ಬಳಕೆದಾರರ ಡೇಟಾವನ್ನು ತರಲು, ನಿಷ್ಕ್ರಿಯ ಬಳಕೆದಾರರನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು, ಮತ್ತು ನಂತರ ಅವರ ಇಮೇಲ್ ವಿಳಾಸಗಳನ್ನು ಹೊರತೆಗೆಯಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ಭಾವಿಸೋಣ.

            
async function* fetchUsers() {
  // Simulate fetching user data from an API
  yield { id: 1, name: 'Alice', email: 'alice@example.com', active: true };
  yield { id: 2, name: 'Bob', email: 'bob@example.com', active: false };
  yield { id: 3, name: 'Charlie', email: 'charlie@example.com', active: true };
  yield { id: 4, name: 'David', email: 'david@example.com', active: false };
}

async function main() {
  const users = fetchUsers();

  const activeUserEmails = users
    .filter(user => user.active)
    .map(user => user.email);

  for await (const email of activeUserEmails) {
    console.log(email); // Output: alice@example.com, charlie@example.com
  }
}

main();

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯು ಬಳಕೆದಾರರ ಡೇಟಾ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ದಕ್ಷವಾಗಿ ಸಂಸ್ಕರಿಸಲು `filter()` ಮತ್ತು `map()` ಅನ್ನು ಜೋಡಿಸುತ್ತದೆ.

ದೋಷ ನಿರ್ವಹಣೆ

ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ದೋಷಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದು ಮುಖ್ಯ. ಜೆನರೇಟರ್ ಅಥವಾ ಹೆಲ್ಪರ್ ಫಂಕ್ಷನ್‌ಗಳೊಳಗೆ ಎಸೆಯಲಾದ ವಿನಾಯಿತಿಗಳನ್ನು ಹಿಡಿಯಲು ನೀವು `try...catch` ಬ್ಲಾಕ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.

            
async function* generateData() {
  yield 1;
  yield 2;
  throw new Error('Something went wrong!');
  yield 3;
}

async function main() {
  const dataStream = generateData();

  try {
    for await (const data of dataStream) {
      console.log(data);
    }
  } catch (error) {
    console.error(`Error: ${error.message}`);
  }
}

main();

            

              
                Copy
              
            
          

ಬಳಕೆಯ ಪ್ರಕರಣಗಳು ಮತ್ತು ಜಾಗತಿಕ ಅನ್ವಯ

ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳು ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಅನ್ವಯವಾಗುತ್ತವೆ, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳು ಅಥವಾ ಅಸಿಂಕ್ರೊನಸ್ ಡೇಟಾ ಮೂಲಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ. ಇಲ್ಲಿ ಕೆಲವು ಉದಾಹರಣೆಗಳಿವೆ:

• ನೈಜ-ಸಮಯದ ಡೇಟಾ ಸಂಸ್ಕರಣೆ: IoT ಸಾಧನಗಳು ಅಥವಾ ಹಣಕಾಸು ಮಾರುಕಟ್ಟೆಗಳಿಂದ ಸ್ಟ್ರೀಮಿಂಗ್ ಡೇಟಾವನ್ನು ಸಂಸ್ಕರಿಸುವುದು. ಉದಾಹರಣೆಗೆ, ವಿಶ್ವದಾದ್ಯಂತ ನಗರಗಳಲ್ಲಿ ಗಾಳಿಯ ಗುಣಮಟ್ಟವನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವ ವ್ಯವಸ್ಥೆಯು ದೋಷಪೂರಿತ ರೀಡಿಂಗ್‌ಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ಮತ್ತು ರೋಲಿಂಗ್ ಸರಾಸರಿಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.
• ಡೇಟಾ ಇಂಜೆಶನ್ ಪೈಪ್‌ಲೈನ್‌ಗಳು: ವಿವಿಧ ಮೂಲಗಳಿಂದ ಡೇಟಾಬೇಸ್‌ಗೆ ಸೇರಿಸುವಾಗ ಡೇಟಾವನ್ನು ಪರಿವರ್ತಿಸುವುದು ಮತ್ತು ಮೌಲ್ಯೀಕರಿಸುವುದು. ವಿಭಿನ್ನ ಮಾರಾಟಗಾರರಿಂದ ಉತ್ಪನ್ನ ವಿವರಣೆಗಳನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಲು ಮತ್ತು ಪ್ರಮಾಣೀಕರಿಸಲು ಜಾಗತಿಕ ಇ-ಕಾಮರ್ಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಈ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಬಳಸುವುದನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ.
• ದೊಡ್ಡ ಫೈಲ್ ಸಂಸ್ಕರಣೆ: ಸಂಪೂರ್ಣ ಫೈಲ್ ಅನ್ನು ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡದೆಯೇ ದೊಡ್ಡ ಫೈಲ್‌ಗಳನ್ನು ತುಂಡುಗಳಲ್ಲಿ ಓದುವುದು ಮತ್ತು ಸಂಸ್ಕರಿಸುವುದು. ಬೃಹತ್ CSV ಫೈಲ್‌ಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾದ ಜಾಗತಿಕ ಹವಾಮಾನ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸುವ ಯೋಜನೆಯು ಇದರಿಂದ ಪ್ರಯೋಜನ ಪಡೆಯಬಹುದು.
• API ಪೇಜಿನೇಶನ್: ಪೇಜಿನೇಟೆಡ್ API ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ದಕ್ಷವಾಗಿ ನಿರ್ವಹಿಸುವುದು. ವಿಭಿನ್ನ ಪೇಜಿನೇಶನ್ ಸ್ಕೀಮ್‌ಗಳೊಂದಿಗೆ ಅನೇಕ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಿಂದ ಡೇಟಾವನ್ನು ಪಡೆಯುವ ಸಾಮಾಜಿಕ ಮಾಧ್ಯಮ ವಿಶ್ಲೇಷಣಾ ಸಾಧನವು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸುಗಮಗೊಳಿಸಲು ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು.
• ಸರ್ವರ್-ಸೆಂಟ್ ಈವೆಂಟ್ಸ್ (SSE) ಮತ್ತು ವೆಬ್‌ಸಾಕೆಟ್‌ಗಳು: ಸರ್ವರ್‌ಗಳಿಂದ ನೈಜ-ಸಮಯದ ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು. ಒಬ್ಬ ಭಾಷಣಕಾರನಿಂದ ಒಂದು ಭಾಷೆಯಲ್ಲಿ ಪಠ್ಯವನ್ನು ಸ್ವೀಕರಿಸಿ ಜಾಗತಿಕವಾಗಿ ಬಳಕೆದಾರರಿಗೆ ಅನುವಾದಿತ ಪಠ್ಯವನ್ನು ಸ್ಟ್ರೀಮ್ ಮಾಡುವ ಲೈವ್ ಅನುವಾದ ಸೇವೆಯು ಈ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು.

ಅತ್ಯುತ್ತಮ ಅಭ್ಯಾಸಗಳು

• ಡೇಟಾ ಹರಿವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ: ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಅತ್ಯುತ್ತಮವಾಗಿಸಲು ನಿಮ್ಮ ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಪೈಪ್‌ಲೈನ್‌ಗಳ ಮೂಲಕ ಡೇಟಾ ಹೇಗೆ ಹರಿಯುತ್ತದೆ ಎಂಬುದನ್ನು ದೃಶ್ಯೀಕರಿಸಿ.
• ದೋಷಗಳನ್ನು ಸೂಕ್ಷ್ಮವಾಗಿ ನಿರ್ವಹಿಸಿ: ಅನಿರೀಕ್ಷಿತ ಅಪ್ಲಿಕೇಶನ್ ಕ್ರ್ಯಾಶ್‌ಗಳನ್ನು ತಡೆಯಲು ದೃಢವಾದ ದೋಷ ನಿರ್ವಹಣೆಯನ್ನು ಅಳವಡಿಸಿ.
• ಸೂಕ್ತ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಬಳಸಿ: ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಅಗತ್ಯಗಳಿಗಾಗಿ ಅತ್ಯಂತ ಸೂಕ್ತವಾದ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಆರಿಸಿ. ಸರಳ ಪರಿಹಾರಗಳು ಇರುವಾಗ ಅತಿಯಾದ ಸಂಕೀರ್ಣ ಹೆಲ್ಪರ್‌ಗಳ ಸರಪಳಿಯನ್ನು ತಪ್ಪಿಸಿ.
• ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಿ: ನಿಮ್ಮ ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಪೈಪ್‌ಲೈನ್‌ಗಳು ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿವೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಯುನಿಟ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಿರಿ. ಎಡ್ಜ್ ಕೇಸ್‌ಗಳು ಮತ್ತು ದೋಷದ ಸ್ಥಿತಿಗಳಿಗೆ ವಿಶೇಷ ಗಮನ ಕೊಡಿ.
• ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಪರಿಗಣಿಸಿ: ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳು ಸುಧಾರಿತ ಓದುವಿಕೆಯನ್ನು ನೀಡುತ್ತವೆಯಾದರೂ, ಅತ್ಯಂತ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಸಂಭಾವ್ಯ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮಗಳ ಬಗ್ಗೆ ಜಾಗರೂಕರಾಗಿರಿ. ಅಗತ್ಯವಿದ್ದಂತೆ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಅಳೆಯಿರಿ ಮತ್ತು ಅತ್ಯುತ್ತಮವಾಗಿಸಿ.

ಪರ್ಯಾಯಗಳು

ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳು ಅಸಿಂಕ್ರೊನಸ್ ಸ್ಟ್ರೀಮ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಅನುಕೂಲಕರ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆಯಾದರೂ, ಪರ್ಯಾಯ ಲೈಬ್ರರಿಗಳು ಮತ್ತು ವಿಧಾನಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ:

• RxJS (ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ಗಾಗಿ ರಿಯಾಕ್ಟಿವ್ ಎಕ್ಸ್‌ಟೆನ್ಶನ್ಸ್): ರಿಯಾಕ್ಟಿವ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗಾಗಿ ಒಂದು ಶಕ್ತಿಯುತ ಲೈಬ್ರರಿ, ಇದು ಅಸಿಂಕ್ರೊನಸ್ ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಪರಿವರ್ತಿಸಲು ಮತ್ತು ಸಂಯೋಜಿಸಲು ಆಪರೇಟರ್‌ಗಳ ಸಮೃದ್ಧ ಗುಂಪನ್ನು ಒದಗಿಸುತ್ತದೆ. RxJS ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳಿಗಿಂತ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿದೆ ಆದರೆ ಹೆಚ್ಚಿನ ನಮ್ಯತೆ ಮತ್ತು ನಿಯಂತ್ರಣವನ್ನು ನೀಡುತ್ತದೆ.
• Highland.js: ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ಗಾಗಿ ಮತ್ತೊಂದು ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್ ಲೈಬ್ರರಿ, ಇದು ಅಸಿಂಕ್ರೊನಸ್ ಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಹೆಚ್ಚು ಕ್ರಿಯಾತ್ಮಕ ವಿಧಾನವನ್ನು ಒದಗಿಸುತ್ತದೆ.
• ಸಾಂಪ್ರದಾಯಿಕ `for await...of` ಲೂಪ್‌ಗಳು: ನೀವು ಹಸ್ತಚಾಲಿತ ಡೇಟಾ ಸಂಸ್ಕರಣಾ ತರ್ಕದೊಂದಿಗೆ ಸಾಂಪ್ರದಾಯಾಯಿಕ `for await...of` ಲೂಪ್‌ಗಳನ್ನು ಬಳಸಿ ಇದೇ ರೀತಿಯ ಫಲಿತಾಂಶಗಳನ್ನು ಸಾಧಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಈ ವಿಧಾನವು ಹೆಚ್ಚು ವಿವರವಾದ ಮತ್ತು ಕಡಿಮೆ ನಿರ್ವಹಿಸಬಲ್ಲ ಕೋಡ್‌ಗೆ ಕಾರಣವಾಗಬಹುದು.

ತೀರ್ಮಾನ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಸಿಂಕ್ ಜೆನರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳು ಅಸಿಂಕ್ರೊನಸ್ ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಶಕ್ತಿಯುತ ಮತ್ತು ಸೊಗಸಾದ ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತವೆ. ಈ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಮತ್ತು ಅವುಗಳ ಸಂಯೋಜನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ ಹೆಚ್ಚು ಓದಬಲ್ಲ, ನಿರ್ವಹಿಸಬಲ್ಲ, ಮತ್ತು ದಕ್ಷ ಕೋಡ್ ಬರೆಯಬಹುದು. ಈ ಆಧುನಿಕ ಸ್ಟ್ರೀಮ್ ಯುಟಿಲಿಟೀಸ್‌ಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವುದು ಸಂಕೀರ್ಣ ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಸವಾಲುಗಳನ್ನು ಆತ್ಮವಿಶ್ವಾಸದಿಂದ ನಿಭಾಯಿಸಲು ಮತ್ತು ಇಂದಿನ ಕ್ರಿಯಾತ್ಮಕ, ಜಾಗತಿಕವಾಗಿ ಸಂಪರ್ಕಗೊಂಡಿರುವ ಜಗತ್ತಿನಲ್ಲಿ ನಿಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿ ಕೌಶಲ್ಯಗಳನ್ನು ಹೆಚ್ಚಿಸಲು ನಿಮಗೆ ಅಧಿಕಾರ ನೀಡುತ್ತದೆ.